/* eslint-disable object-curly-newline,prefer-destructuring */

/*   用于存放业务逻辑   */
import moment from 'moment';
import { message } from 'antd';
import * as config from '../../../utils/config';
import * as utils from '../../../utils/utils';
import * as services from '../../../services/services';
import * as salesBusiness from './sales/salesBusiness';
import * as salesOrderBusiness from './sales/salesOrder/salesOrderBusiness';
import * as salesDeliverBusiness from './sales/salesOrder/salesDeliverBusiness';
import * as comFunc from '../../Common/ComFunc';

// ----------------------------按钮相关功能start---------------------------- //
// -------------------------新增行相关功能start------------------------- //
/**   新增行业务   */
export function doAddRowBusiness(addSlaveRow, props) {
  /*   返回值   */
  // const { masterConfig } = props;
  const sModelType = 'salesOrder';
  // const { sModelType } = masterConfig;
  /*   销售业务   */
  if (sModelType.startsWith('sales')) {
    const { masterData } = props;
    /*   客户名称为空时不允许增加行   */
    addSlaveRow = salesBusiness.doAddRowBusinessSales(addSlaveRow, props, message);
    if (utils.isEmptyObject(addSlaveRow)) return addSlaveRow;
    /*   税率和税率id带到从表   */
    addSlaveRow = salesBusiness.changeSlaveTaxRateTaxIdByMaster(masterData, addSlaveRow);
    /*   销售订单业务   */
    if (sModelType === 'salesOrder') {
      return salesOrderBusiness.doAddRowBusinessSalesOrder(addSlaveRow, props);
    }
    /*   销售送货单业务   */
    if (sModelType === 'salesDeliver') {
      return salesDeliverBusiness.doAddRowBusinessSalesDeliver(addSlaveRow, props);
    }
  }
  /*   返回值   */
  return addSlaveRow;
}
// -------------------------新增行相关功能end  ------------------------- //
// ----------------------------按钮相关功能end  ---------------------------- //

// ----------------------------toolbar相关功能start---------------------------- //
// -------------------------保存相关功能start------------------------- //
/**   保存验证   */
export function handleSaveValidate(props) {
  /*   待用数据赋值   */
  const { masterData, gdsformconst } = props;
  // const { sModelType } = masterConfig;
  const sModelType = 'salesOrder';
  /*   保存错误信息声明   */
  props.saveError = '';
  /*   验证保存信息   */
  if (masterData.bCheck) { /*   审核订单不能保存   */
    props.saveError = gdsformconst.filter(item => (item.sName === 'sToExamineCheck'))[0].showName;
  } else if (sModelType.startsWith('sales')) { /*   销售订单从表不能为空   */
    props = salesBusiness.handleSaveValidate(props);
  }
  /*   返回值   */
  return props;
}

/*   上一条、下一条、首条、末条从表刷新   */
export function handleSlaveData(props) {
  const { dataTotal, slaveShowConfig } = props;
  // const { sModelType } = masterConfig;
  const sModelType = 'salesOrder';
  let { slaveData } = props;
  if (sModelType === 'salesOrder') {
    if (utils.isNotEmptyArr(slaveData)) {
      slaveData = salesOrderBusiness.handleSaveSlave(slaveData);
    }
  }
  /*   重新做合计   */
  if (utils.isNotEmptyArr(slaveData)) {
    props.slaveTotal = comFunc.addDataTotal(slaveShowConfig, dataTotal, slaveData, true);
  }
  return props;
}
// -------------------------保存相关功能end  ------------------------- //
// ----------------------------toolbar相关功能start---------------------------- //

// ----------------------------单据相关功能start---------------------------- //
// -------------------------查看业务start------------------------- //
/**   查看单据时需要执行的业务   */
export function handleView(props) {
  /*   待用数据声明   */
  const { slaveShowConfig, dataTotal, slaveData, isNeedStatisticsTotal } = props;
  /*   添加从表数据中的handleType='update'   */
  props = addSlaveDataHandleType(props);
  /*   添加合计   */
  props.slaveTotal = comFunc.addDataTotal(slaveShowConfig, dataTotal, slaveData, isNeedStatisticsTotal);
  /*   渲染处理   */
  props = handleViewRender(props);
  /*   返回值   */
  return props;
}

/*   添加从表数据中的handleType   */
export function addSlaveDataHandleType(props) {
  /*   待用数据声明   */
  const { slaveData, copyToData } = props;
  /*   从表数据不为空的情况下才进行遍历   */
  if (utils.isNotEmptyArr(slaveData)) {
    /*   遍历从表数据   */
    for (const each of slaveData) {
      /*   非复制到的数据handleType全都是update,复制到数据handleType全是add并且全是change状态   */
      if (utils.isEmptyObject(copyToData)) {
        each.handleType = 'update';
      } else {
        each.handleType = 'add';
        each.bIsChange = true;
      }
    }
  }
  /*   返回值   */
  return props;
}

/*   渲染处理   */
export function handleViewRender(props) {
  const { masterShowConfig, slaveShowConfig, checkShowConfig, slaveData, checkData } = props;
  /*   返回值赋值   */
  props.isMasterRender = comFunc.setMasterRenderTrueOrFalse(masterShowConfig, false);
  props.isSlaveRender = comFunc.setSlaveRenderTrueOrFalse(slaveShowConfig, slaveData, false);
  props.isCheckRender = comFunc.setSlaveRenderTrueOrFalse(checkShowConfig, checkData, false);
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   应收款，到期应收   */
export async function getOutData(props) {
  /*   待用数据声明   */
  const { sModelsId, masterData, app, masterShowConfig, slaveShowConfig, checkShowConfig, slaveData, checkData } = props;
  const { sCustomerId } = masterData;
  /*   执行条件  */
  if (utils.isNotEmptyStr(sCustomerId)) {
    /*   参数声明   */
    const tStartDate = moment().subtract(1, 'days').format(utils.dateFormatA); /* 前一天 */
    const tEndDate = moment().add(1, 'days').format(utils.dateFormatA); /* 后一天 */
    const paramsMap = { iType: '0', sStatistics: sCustomerId, tStartDate, tEndDate };
    const value = { sProName: 'Sp_Receivables_AR', paramsMap };
    const url = `${config.server_host}business/getProData?sModelsId=${sModelsId}`;
    /*   调用接口获取数据   */
    const { data } = await services.postValueService(app.token, value, url);
    /*   判断返回数据是否成功   */
    if (data.code === 1) { /*   返回成功   */
      /*   给主表的应收应付款赋值   */
      const outDataRetrun = data.dataset.rows[0].dataSet.outData;
      if (utils.isNotEmptyArr(outDataRetrun)) {
        masterData.dAccountReceivable = outDataRetrun[0].dNoReceiptMoney; /* 应收款 */
        masterData.dExpireReceivable = outDataRetrun[0].dDueReceiptMoney; /* 到期应收 */
      }
    } else { /*   返回失败   */
      message.error(data.msg);
      /*   返回值   */
      return undefined;
    }
  }
  /*   主表渲染对象   */
  const masterShowRender = ['dAccountReceivable', 'dExpireReceivable'];
  /*   返回值赋值   */
  props.isMasterRender = comFunc.setMasterRender(masterShowConfig, masterShowRender);
  props.isSlaveRender = comFunc.setSlaveRenderTrueOrFalse(slaveShowConfig, slaveData, false);
  props.isCheckRender = comFunc.setSlaveRenderTrueOrFalse(checkShowConfig, checkData, false);
  props.editTableRender = false;
  /*   返回值   */
  return props;
}
// -------------------------查看业务end  ------------------------- //
// ----------------------------单据相关功能end  ---------------------------- //

// ----------------------------数据修改相关功能start---------------------------- //
// -------------------------主表数据修改start------------------------- //
/**  更改主表数据  */
export function handleMasterSpecial(props) {
  /*   待用数据声明   */
  // const { masterConfig } = props;
  // const { sModelType } = masterConfig;
  const sModelType = 'salesOrder';
  const key = getChangeSName(props);
  const obj = { decimals: props.app.decimals };
  /*   下拉赋值字段处理   */
  props = handleMasterDropDownAssign(props);
  /*   业务区分   */
  if (sModelType.startsWith('sales')) { /*   销售模块   */
    /*   用于汇率计算中公共sName的相同特征   */
    obj.sName = 'Product';
    /*   计算结算日期   */
    if (key === 'sCustomerId' || key === 'sGetPayId' || key === 'tDeliverDate') {
      props = salesBusiness.getGeyPayDate(props);
    }
    /*   销售订单的特殊处理   */
    if (sModelType === 'salesOrder') {
      /*   销售订单交货日期带到从表中去   */
      if (key === 'tDeliverDate') {
        props = salesOrderBusiness.saleOrderDeliveDataFromMasterToSlave(props);
      }
      /*   销售订单的主表客户名称改变时从表的印件分类也都需要做相应的处理的渲染处理   */
      if (key === 'sCustomerId') {
        props = salesOrderBusiness.setSaleSlaveProductIdRenderByMasterCustomerId(props);
      }
    } else if (sModelType === 'salesDeliver') { /*   销售送货单的特殊处理   */
      if (key === 'sWareHouseId') {
        props = salesDeliverBusiness.saleDeliverWareHouseIdFromMasterToSlave(props);
      }
    }
  }
  /*   税额税率   */
  if (key === 'dCurrencyRate' || key === 'sCurrency' || key === 'sCustomerId') {
    props = getCalculateByCurrencyRate(props, obj);
  }
  /*   待用数据声明   */
  const { masterShowConfig, masterShowRender, slaveShowConfig, slaveData, slaveShowRender, checkShowConfig, checkData, checkShowRender } = props;
  props.isMasterRender = comFunc.setMasterRender(masterShowConfig, masterShowRender);
  props.isSlaveRender = comFunc.setSlaveRender(slaveShowConfig, slaveData, slaveShowRender);
  props.isCheckRender = comFunc.setSlaveRender(checkShowConfig, checkData, checkShowRender);
  /*   返回值   */
  return props;
}

/**    主表下拉赋值字段处理    */
export function handleMasterDropDownAssign(props) {
  /*   获取下拉字段的sName   */
  const sName = getChangeSName(props);
  /*   获取下拉数据的整行值   */
  const changeDataRow = salesBusiness.getMasterDrowDownChangeDataRow(props);
  /*   反正这个字段是肯定是要渲染的   */
  const masterShowRender = [sName];
  /*   如果下拉数据   */
  if (utils.isNotEmptyObject(changeDataRow)) {
    /*   待用数据声明   */
    const { masterShowConfig, masterData } = props;
    const changeConfig = masterShowConfig.filter(item => item.sName === sName)[0];
    const { sAssignField } = changeConfig;
    const sAssignFieldObj = utils.returnObjValue(sAssignField);
    /*   存在赋值字段才对赋值字段进行处理   */
    if (utils.isNotEmptyObject(sAssignField)) {
      /*   遍历赋值字段对象   */
      for (const key of Object.keys(sAssignFieldObj)) {
        /*    获取赋值字段的value   */
        const value = sAssignFieldObj[key];
        if (utils.isNotUndefined(value)) {
          /*   主表数据赋值   */
          masterData[key] = changeDataRow[value];
          /*   渲染值控制   */
          masterShowRender.push(key);
        }
      }
    }
  }
  /*   返回值赋值   */
  props.masterShowRender = masterShowRender;
  /*   返回值   */
  return props;
}

/**   获取发生改变的列名   */
export function getChangeSName(props) {
  /*   返回值声明   */
  let res = '';
  /*   待用数据赋值   */
  const { changeValue } = props;
  /*   返回值赋值   */
  if (utils.isNotEmptyObject(changeValue)) {
    res = Object.keys(changeValue)[0];
  }
  /*   返回值   */
  return res;
}

/**   汇率计算   */
export function getCalculateByCurrencyRate(props, obj) {
  /*   待用数据声明   */
  const { slaveShowConfig, dataTotal, copyToData, slaveData } = props;
  const { sName } = obj;
  let { slaveShowRender } = props;
  slaveShowRender = utils.convertUndefinedToEmptyObject(slaveShowRender);
  /*   遍历从表数据   */
  for (const item of slaveData) {
    /*   非合计项才进行税率计算   */
    if (!item.dataTotal) {
      /*   税率计算   */
      getResultByCurrencyRate(item, props, obj);
      /*   渲染   */
      let slaveShowRenderEach = slaveShowRender[item.sId];
      slaveShowRenderEach = utils.convertUndefinedToEmptyArr(slaveShowRenderEach);
      slaveShowRenderEach.push(`d${sName}ForeignMoney`);
      slaveShowRenderEach.push(`d${sName}TaxForeignMoney`);
      slaveShowRender[item.sId] = slaveShowRenderEach;
    }
  }
  /*   是否需要统计   */
  const isNeed = props.isNeedStatisticsTotal || utils.isNotEmptyObject(copyToData);
  /*   添加合计项   */
  props.slaveTotal = comFunc.addDataTotal(slaveShowConfig, dataTotal, slaveData, isNeed);
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   外币金额，外币税额计算   */
export function getResultByCurrencyRate(item, props, obj) {
  /*   待用数据声明   */
  const { sName, decimals } = obj;
  const { dNetMoney } = decimals;
  const { masterData } = props;
  /*   税率计算的先决条件   */
  if (utils.isNum(item[`d${sName}Money`]) && utils.isNum(item[`d${sName}TaxMoney`]) && utils.isNum(masterData.dCurrencyRate)) {
    /*   待用数据赋值   */
    const dProductMoney = utils.parseFloatNum(item[`d${sName}Money`]);
    const dProductTaxMoney = utils.parseFloatNum(item[`d${sName}TaxMoney`]);
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate);
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0;
    /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0;
    /* 外币税额 */
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
  }
}
// -------------------------主表数据修改end  ------------------------- //

// -------------------------从表数据修改start------------------------- //
/**   处理从表数据变更   */
export function handleSlaveChange(props) {
  /*   修改从表值   */
  props = changeSlaveValue(props);
  /*   下拉数据处理   */
  props = handleSlaveDropDownAssign(props);
  /*   待用数据声明   */
  const { masterConfig, slaveData, slaveShowConfig, dataTotal } = props;
  const { sModelType } = masterConfig;
  const obj = { decimals: props.app.decimals };
  /*   销售订单的特殊处理   */
  if (sModelType.startsWith('sales')) {
    obj.sName = 'Product';
    if (sModelType === 'salesDeliver') {
      /* 箱包计算 */
      props = salesDeliverBusiness.getCalculateBag(props, obj);
    }
  }
  /* 各种金额，税额，价格计算 */
  props = getCalculateAllMoney(props, obj);
  /*   重新做合计   */
  if (utils.isNotEmptyArr(slaveData)) {
    props.slaveTotal = comFunc.addDataTotal(slaveShowConfig, dataTotal, slaveData, true);
  }
  /*   待用数据声明   */
  const { masterShowConfig, masterShowRender, slaveShowRender, checkShowConfig, checkData, checkShowRender } = props;
  props.isMasterRender = comFunc.setMasterRender(masterShowConfig, masterShowRender);
  props.isSlaveRender = comFunc.setSlaveRender(slaveShowConfig, slaveData, slaveShowRender);
  props.isCheckRender = comFunc.setSlaveRender(checkShowConfig, checkData, checkShowRender);
  /*   返回值  */
  return props;
}

/**    从表下拉赋值字段处理    */
export function handleSlaveDropDownAssign(props) {
  /*   获取下拉字段的sName   */
  const sName = getChangeSName(props);
  /*   获取下拉数据的整行值   */
  const changeDataRow = salesBusiness.getSlaveDrowDownChangeDataRow(props);
  /*   如果下拉数据   */
  if (utils.isNotEmptyObject(changeDataRow)) {
    /*   待用数据声明   */
    const { slaveShowConfig, sSlaveId, slaveData, masterData, slaveShowRender } = props;
    const changeConfig = slaveShowConfig.filter(item => item.sName === sName)[0];
    const { sAssignField } = changeConfig;
    const sAssignFieldObj = utils.returnObjValue(sAssignField);
    /*   存在赋值字段才对赋值字段进行处理   */
    if (utils.isNotEmptyObject(sAssignField)) {
      /*   遍历赋值字段对象   */
      for (const key of Object.keys(sAssignFieldObj)) {
        /*    获取赋值字段的value   */
        const value = sAssignFieldObj[key];
        if (utils.isNotUndefined(value)) {
          /*   如果是#xxx#这种格式的数据就从主表取,否则从从表取   */
          const index = slaveData.findIndex(item => item.sId === sSlaveId);
          const slaveDataEach = slaveData[index];
          if (value.startsWith('#') && value.endsWith('#')) {
            slaveDataEach[key] = masterData[value.replace('#', '')];
          } else {
            slaveDataEach[key] = changeDataRow[value];
          }
          /*   渲染值控制   */
          slaveShowRender[sSlaveId].push(key);
        }
      }
    }
    /*   返回值赋值   */
    props.slaveData = slaveData;
    props.slaveShowRender = slaveShowRender;
  }
  /*   返回值   */
  return props;
}

/*   修改从表的值   */
export function changeSlaveValue(props) {
  /*   待用数据赋值   */
  const { changeValue, sSlaveId, slaveData } = props;
  /*   获取下拉字段的sName   */
  const sName = getChangeSName(props);
  /*   给从表数据赋值   */
  const index = slaveData.findIndex(item => item.sId === sSlaveId);
  const slaveDataEach = slaveData[index];
  slaveDataEach[sName] = changeValue[sName];
  /*   设置从表渲染   */
  const slaveShowRender = {};
  slaveShowRender[sSlaveId] = [sName];
  /*   返回值赋值   */
  props.slaveData = slaveData;
  props.slaveShowRender = slaveShowRender;
  /*   返回值   */
  return props;
}

/**   根据不同的模块，选出具体计算不同模块的计算方式等   */
export function getCalculateAllMoney(props, obj) {
  /*   获取修改字段的key   */
  const key = getChangeSName(props);
  /*   待用数据声明   */
  const { sName } = obj;
  /*   不同的数据进行不同的处理   */
  if (key === `d${sName}Qty` || key === `d${sName}Price` || key === 'sTaxId') {
    props = salesDeliverBusiness.getCalculateByPrice(props, obj);
    if (key === `d${sName}Price`) {
      props = getCalculatedLossMoney(props, obj);
    }
    if (key === `d${sName}Qty`) {
      props = getCalculatedReserveBags(props, obj);
    }
  }
  if (key === `d${sName}Money`) {
    props = getCalculateMoney(props, obj);
  }
  if (key === `d${sName}NoTaxPrice`) {
    props = getCalculateNoTaxPrice(props, obj);
  }
  if (key === `d${sName}NoTaxMoney`) {
    props = getCalculateNoTaxMoney(props, obj);
  }
  if (key === 'dLossQty') {
    props = getCalculatedLossMoney(props, obj);
  }
  return props;
}

/**   输入报损数量   */
export function getCalculatedLossMoney(props, obj) {
  /*   带用数据声明   */
  const { sSlaveId, slaveShowRender } = props;
  const item = salesDeliverBusiness.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  /*   执行条件   */
  if (utils.isNum(item.dLossQty) && utils.isNum(item[`d${sName}Price`])) {
    /*   待用数据赋值   */
    const { dNetMoney } = decimals;
    const dLossQty = utils.parseFloatNum(item.dLossQty); /* 报损换算数量 */
    const dProductPrice = utils.parseFloatNum(item[`d${sName}Price`]);
    const dLossMoney = dLossQty * dProductPrice;
    /*   数据赋值   */
    item.dLossMoney = utils.convertFixNum(dLossMoney, dNetMoney);
    /*   渲染赋值   */
    const slaveShowRenderEach = slaveShowRender[sSlaveId];
    slaveShowRenderEach.push('dLossQty');
    slaveShowRenderEach.push('dLossMoney');
    slaveShowRenderEach.push(`d${sName}Price`);
  }
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   输入数量, 计算箱包   */
export function getCalculatedReserveBags(props, obj) {
  /*   待用数据声明   */
  const { sSlaveId, slaveShowRender } = props;
  const item = salesDeliverBusiness.getChangeSlaveItem(props);
  const { sName } = obj;
  /*   执行条件   */
  if (utils.isNum(item[`d${sName}Qty`])) {
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dTrunkQty = utils.convertIsNotNumToNumber1(item.dTrunkQty); /* 数量/箱 */
    const dPackQty = dTrunkQty !== 0 ? dProductQty / dTrunkQty : 0; /* 包数 */
    const dFractionQty = dTrunkQty !== 0 ? dProductQty - (dPackQty / dTrunkQty) : 0; /* 零头数量 */
    /*   数据赋值   */
    item.dPackQty = utils.convertStrToNumberUndefined(dPackQty);
    item.dFractionQty = utils.convertStrToNumberUndefined(dFractionQty);
    /*   渲染赋值   */
    const slaveShowRenderEach = slaveShowRender[sSlaveId];
    slaveShowRenderEach.push('dPackQty');
    slaveShowRenderEach.push('dFractionQty');
  }
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   根据金额，具体计算价格，不含税金额，不含税价格，税额，外币金额，外币税额   */
export function getCalculateMoney(props, obj) {
  /*   待用数据声明   */
  const { sSlaveId, slaveShowRender, masterData } = props;
  const item = salesDeliverBusiness.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  /*   执行条件   */
  if (utils.isNum(item[`d${sName}Money`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(item.dTaxRate) && utils.isNum(masterData.dCurrencyRate)) {
    /*   待用数据赋值   */
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dProductMoney = utils.parseFloatNum(item[`d${sName}Money`]); /* 金额 */
    const dTaxRate = utils.parseFloatNum(item.dTaxRate); /* 税率 */
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate); /* 汇率 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductNoTaxMoney = dProductMoney / (1 + (dTaxRate / 100)); /* 不含税金额 */
    const dProductNoTaxPrice = dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0; /* 不含税价 */
    const dProductTaxMoney = dProductMoney - dProductNoTaxMoney; /* 税额 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    /*   数据赋值   */
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}NoTaxMoney`] = utils.convertFixNum(dProductNoTaxMoney, dNetMoney);
    item[`d${sName}NoTaxPrice`] = utils.convertFixNum(dProductNoTaxPrice, dNetPrice);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    /*   渲染赋值   */
    const slaveShowRenderEach = slaveShowRender[sSlaveId];
    slaveShowRenderEach.push(`d${sName}Price`);
    slaveShowRenderEach.push(`d${sName}NoTaxMoney`);
    slaveShowRenderEach.push(`d${sName}NoTaxPrice`);
    slaveShowRenderEach.push(`d${sName}TaxMoney`);
    slaveShowRenderEach.push(`d${sName}ForeignMoney`);
    slaveShowRenderEach.push(`d${sName}TaxForeignMoney`);
  }
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  return props;
}

/**   输入不含税价格, 计算不含税金额，税额，金额，价格，外币金额，外币税额   */
export function getCalculateNoTaxPrice(props, obj) {
  /*   待用数据声明   */
  const { sSlaveId, slaveShowRender, masterData } = props;
  const item = salesDeliverBusiness.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  /*   执行条件   */
  if (utils.isNum(item[`d${sName}NoTaxPrice`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    /*   待用数据赋值   */
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]); /* 数量 */
    const dProductNoTaxPrice = utils.parseFloatNum(item[`d${sName}NoTaxPrice`]); /* 不含税价 */
    const dTaxRate = utils.parseFloatNum(item.dTaxRate); /* 税率 */
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate); /* 汇率 */
    const dProductNoTaxMoney = dProductQty * dProductNoTaxPrice; /* 不含税金额 */
    const dProductTaxMoney = dProductNoTaxMoney * (dTaxRate / 100); /* 税额 */
    const dProductMoney = dProductNoTaxMoney + dProductTaxMoney; /* 金额 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    /*   数据赋值   */
    item[`d${sName}NoTaxMoney`] = utils.convertFixNum(dProductNoTaxMoney, dNetMoney);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}Money`] = utils.convertFixNum(dProductMoney, dNetMoney);
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    /*   渲染赋值   */
    const slaveShowRenderEach = slaveShowRender[sSlaveId];
    slaveShowRenderEach.push(`d${sName}NoTaxMoney`);
    slaveShowRenderEach.push(`d${sName}TaxMoney`);
    slaveShowRenderEach.push(`d${sName}Money`);
    slaveShowRenderEach.push(`d${sName}Price`);
    slaveShowRenderEach.push(`d${sName}ForeignMoney`);
    slaveShowRenderEach.push(`d${sName}TaxForeignMoney`);
  }
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}

/**   输入不含税金额， 计算不含税价格，税额，金额，价格，外币金额，外币税额   */
export function getCalculateNoTaxMoney(props, obj) {
  /*   待用数据声明   */
  const { sSlaveId, slaveShowRender, masterData } = props;
  const item = salesDeliverBusiness.getChangeSlaveItem(props);
  const { sName, decimals } = obj;
  /*   执行条件   */
  if (utils.isNum(item[`d${sName}NoTaxMoney`]) && utils.isNum(item[`d${sName}Qty`]) && utils.isNum(masterData.dCurrencyRate)) {
    /*   待用数据赋值   */
    const { dNetPrice, dNetMoney } = decimals;
    const dProductQty = utils.parseFloatNum(item[`d${sName}Qty`]);
    const dProductNoTaxMoney = utils.parseFloatNum(item[`d${sName}NoTaxMoney`]);
    const dTaxRate = utils.parseFloatNum(item.dTaxRate);
    const dCurrencyRate = utils.parseFloatNum(masterData.dCurrencyRate);
    const dProductNoTaxPrice = dProductQty !== 0 ? dProductNoTaxMoney / dProductQty : 0; /* 不含税价格 */
    const dProductTaxMoney = dProductNoTaxMoney * (dTaxRate / 100); /* 税额 */
    const dProductMoney = dProductNoTaxMoney + dProductTaxMoney; /* 金额 */
    const dProductPrice = dProductQty !== 0 ? dProductMoney / dProductQty : 0; /* 价格 */
    const dProductForeignMoney = dCurrencyRate !== 0 ? dProductMoney / dCurrencyRate : 0; /* 外币金额 */
    const dProductTaxForeignMoney = dCurrencyRate !== 0 ? dProductTaxMoney / dCurrencyRate : 0; /* 外币税额 */
    /*   数据赋值   */
    item[`d${sName}NoTaxPrice`] = utils.convertFixNum(dProductNoTaxPrice, dNetPrice);
    item[`d${sName}TaxMoney`] = utils.convertFixNum(dProductTaxMoney, dNetMoney);
    item[`d${sName}Money`] = utils.convertFixNum(dProductMoney, dNetMoney);
    item[`d${sName}Price`] = utils.convertFixNum(dProductPrice, dNetPrice);
    item[`d${sName}ForeignMoney`] = utils.convertFixNum(dProductForeignMoney, dNetMoney);
    item[`d${sName}TaxForeignMoney`] = utils.convertFixNum(dProductTaxForeignMoney, dNetMoney);
    /*   渲染赋值   */
    const slaveShowRenderEach = slaveShowRender[sSlaveId];
    slaveShowRenderEach.push(`d${sName}NoTaxPrice`);
    slaveShowRenderEach.push(`d${sName}TaxMoney`);
    slaveShowRenderEach.push(`d${sName}Money`);
    slaveShowRenderEach.push(`d${sName}Price`);
    slaveShowRenderEach.push(`d${sName}ForeignMoney`);
    slaveShowRenderEach.push(`d${sName}TaxForeignMoney`);
  }
  /*   返回值赋值   */
  props.slaveShowRender = slaveShowRender;
  props.editTableRender = true;
  /*   返回值   */
  return props;
}
// -------------------------从表数据修改end  ------------------------- //
// ----------------------------数据修改相关功能end  ---------------------------- //

// ----------------------------其它相关功能start---------------------------- //
/**   主表对于disabled的处理   */
export function dealMasterDisabled(props) {
  /*   待用数据声明   */
  const { masterShowConfig, slaveData, isMasterRender } = props;
  // const { sModelType } = masterConfig;
  const sModelType = 'salesOrder';
  /*   执行条件   */
  if (utils.isNotEmptyArr(masterShowConfig)) {
    /*   遍历所有配置添加特殊控制(用于控制disabled)   */
    for (const showConfig of masterShowConfig) {
      /*   销售模块的从表不为空时sCustomerId不可编辑   */
      if (sModelType.startsWith('sales')) {
        const oldSpecialControl = showConfig.specialControl;
        const newSpecialControl = showConfig.sName === 'sCustomerId' && utils.isNotEmptyArr(slaveData);
        if (oldSpecialControl !== newSpecialControl) {
          showConfig.specialControl = newSpecialControl;
          isMasterRender.sCustomerId = true;
        }
      }
    }
  }
  /*   返回值   */
  return props;
}
// ----------------------------其它相关功能end  ---------------------------- //
